 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  * IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.ui.wizards.datatransfer;

 import java.io.File ;
 import java.lang.reflect.InvocationTargetException ;
 import java.util.*;
 import java.util.List ;

 import org.eclipse.core.runtime.*;
 import org.eclipse.jface.dialogs.*;
 import org.eclipse.jface.viewers.*;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.layout.GridData;
 import org.eclipse.swt.layout.GridLayout;
 import org.eclipse.swt.widgets.*;
 import org.eclipse.ui.*;
 import org.eclipse.ui.dialogs.*;

 /**
  * Page 1 of the base resource import-from-file-system Wizard
  * @deprecated use WizardFileSystemResourceImportPage1
  */
 /*package*/ class WizardFileSystemImportPage1 extends WizardImportPage implements ISelectionChangedListener, Listener {
     private List selectedResources;
     private FileSystemElement root;

     // widgets
 protected Combo typesToImportField;
     protected Button typesToImportEditButton;
     protected Combo sourceNameField;
     protected Button sourceBrowseButton;
     protected Button importAllResourcesRadio;
     protected Button importTypedResourcesRadio;
     protected Button detailsButton;
     protected Label detailsDescriptionLabel;
     protected Button overwriteExistingResourcesCheckbox;
     protected Button createContainerStructureCheckbox;
     
     // constants
 private static final int SIZING_TEXT_FIELD_WIDTH = 250;
     private static final String TYPE_DELIMITER = DataTransferMessages.getString("DataTransfer.typeDelimiter"); //$NON-NLS-1$

     // dialog store id constants
 private final static String STORE_SOURCE_NAMES_ID = "WizardFileSystemImportPage1.STORE_SOURCE_NAMES_ID";//$NON-NLS-1$
 private final static String STORE_IMPORT_ALL_RESOURCES_ID = "WizardFileSystemImportPage1.STORE_IMPORT_ALL_FILES_ID";//$NON-NLS-1$
 private final static String STORE_OVERWRITE_EXISTING_RESOURCES_ID = "WizardFileSystemImportPage1.STORE_OVERWRITE_EXISTING_RESOURCES_ID";//$NON-NLS-1$
 private final static String STORE_CREATE_CONTAINER_STRUCTURE_ID = "WizardFileSystemImportPage1.STORE_CREATE_CONTAINER_STRUCTURE_ID";//$NON-NLS-1$
 private final static String STORE_SELECTED_TYPES_ID = "WizardFileSystemImportPage1.STORE_SELECTED_TYPES_ID";//$NON-NLS-1$
 /**
  * Creates an instance of this class
  */
 protected WizardFileSystemImportPage1(String name, IWorkbench aWorkbench, IStructuredSelection selection) {
     super(name,selection);
 }
 /**
  * Creates an instance of this class
  */
 public WizardFileSystemImportPage1(IWorkbench aWorkbench, IStructuredSelection selection) {
     this("fileSystemImportPage1", aWorkbench, selection);//$NON-NLS-1$
 setTitle(DataTransferMessages.getString("DataTransfer.fileSystemTitle")); //$NON-NLS-1$
 setDescription(DataTransferMessages.getString("FileImport.importFileSystem")); //$NON-NLS-1$
 }
 /**
  * Adds the recursive contents of the passed file system element to this
  * page's collection of selected resources.
  */
 protected void addToSelectedResources(FileSystemElement element) {
     if (element.isDirectory()) {
         Object [] children = element.getFolders().getChildren(element);
         for (int i = 0; i < children.length; ++i) {
             addToSelectedResources((FileSystemElement) children[i]);
         }
         children = element.getFiles().getChildren(element);
         for (int i = 0; i < children.length; ++i) {
             addToSelectedResources((FileSystemElement) children[i]);
         }
     } else
         selectedResources.add(element);
 }
 /**
  * Create the import options specification widgets.
  */
 protected void createOptionsGroup(Composite parent) {
     // options group
 Composite optionsGroup = new Composite(parent, SWT.NONE);
     GridLayout layout = new GridLayout();
     layout.marginHeight = 0;
     optionsGroup.setLayout(layout);
     optionsGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL));

     // overwrite... checkbox
 overwriteExistingResourcesCheckbox = new Button(optionsGroup,SWT.CHECK);
     overwriteExistingResourcesCheckbox.setText(DataTransferMessages.getString("FileImport.overwriteExisting")); //$NON-NLS-1$

     // create containers checkbox
 createContainerStructureCheckbox = new Button(optionsGroup,SWT.CHECK);
     createContainerStructureCheckbox.setText(DataTransferMessages.getString("FileImport.createComplete")); //$NON-NLS-1$
 }
 /**
  * Create the import source specification widgets
  */
 protected void createSourceGroup(Composite parent) {
     Composite sourceContainerGroup = new Composite(parent,SWT.NONE);
     GridLayout layout = new GridLayout();
     layout.numColumns = 3;
     sourceContainerGroup.setLayout(layout);
     sourceContainerGroup.setLayoutData(
         new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL));

     new Label(sourceContainerGroup,SWT.NONE).setText(getSourceLabel());

     // source name entry field
 sourceNameField = new Combo(sourceContainerGroup,SWT.BORDER);
     sourceNameField.addListener(SWT.Modify,this);
     sourceNameField.addListener(SWT.Selection,this);
     GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
     data.widthHint = SIZING_TEXT_FIELD_WIDTH;
     sourceNameField.setLayoutData(data);

     // source browse button
 sourceBrowseButton = new Button(sourceContainerGroup,SWT.PUSH);
     sourceBrowseButton.setText(DataTransferMessages.getString("DataTransfer.browse")); //$NON-NLS-1$
 sourceBrowseButton.addListener(SWT.Selection,this);
     sourceBrowseButton.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL));

     // source types group
 Composite sourceTypesGroup = new Composite(parent,SWT.NONE);
     layout = new GridLayout();
     layout.numColumns = 3;
     sourceTypesGroup.setLayout(layout);
     sourceTypesGroup.setLayoutData(
         new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL));

     // all types radio
 importAllResourcesRadio = new Button(sourceTypesGroup,SWT.RADIO);
     importAllResourcesRadio.setText(DataTransferMessages.getString("DataTransfer.allTypes")); //$NON-NLS-1$
 importAllResourcesRadio.addListener(SWT.Selection,this);
     data = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
     data.horizontalSpan = 3;
     importAllResourcesRadio.setLayoutData(data);

     // import specific types radio
 importTypedResourcesRadio = new Button(sourceTypesGroup,SWT.RADIO);
     importTypedResourcesRadio.setText(DataTransferMessages.getString("FileImport.filesofType")); //$NON-NLS-1$
 importTypedResourcesRadio.addListener(SWT.Selection,this);

     // types combo
 typesToImportField = new Combo(sourceTypesGroup, SWT.NONE);
     data = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
     data.widthHint = SIZING_TEXT_FIELD_WIDTH;
     typesToImportField.setLayoutData(data);
     typesToImportField.addListener(SWT.Modify, this);

     // types edit button
 typesToImportEditButton = new Button(sourceTypesGroup, SWT.PUSH);
     typesToImportEditButton.setText(DataTransferMessages.getString("FileImport.edit")); //$NON-NLS-1$
 typesToImportEditButton.setLayoutData(new GridData(
         GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_END));
     typesToImportEditButton.addListener(SWT.Selection, this);

     // details of files to import group
 Composite fileDetailsGroup = new Composite(parent, SWT.NONE);
     layout = new GridLayout();
     layout.numColumns = 2;
     fileDetailsGroup.setLayout(layout);
     fileDetailsGroup.setLayoutData(new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL));

     // details button
 detailsButton = new Button(fileDetailsGroup,SWT.PUSH);
     detailsButton.setText(DataTransferMessages.getString("DataTransfer.details")); //$NON-NLS-1$
 detailsButton.addListener(SWT.Selection,this);

     // details label
 detailsDescriptionLabel = new Label(fileDetailsGroup,SWT.NONE);
     data = new GridData(GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL);
     detailsDescriptionLabel.setLayoutData(data);

     // initial setup
 typesToImportField.setEnabled(false);
     typesToImportEditButton.setEnabled(false);
     importAllResourcesRadio.setSelection(true);
     resetSelection();
     sourceNameField.setFocus();
 }
 /**
  * Display the appropriate string representing a selection of the
  * passed size.
  */
 protected void displaySelectedCount(int selectedFileCount) {
     if (selectedFileCount == 1)
         detailsDescriptionLabel.setText(
             DataTransferMessages.getString("DataTransfer.oneSelected")); //$NON-NLS-1$
 else
         detailsDescriptionLabel.setText(DataTransferMessages.format("FileImport.filesSelected",new Object [] {String.valueOf(selectedFileCount)})); //$NON-NLS-1$
 }
 /**
  * Answer a boolean indicating whether the specified source currently exists
  * and is valid
  */
 protected boolean ensureSourceIsValid() {
     if (new File (getSourceDirectoryName()).isDirectory())
         return true;

     displayErrorDialog(DataTransferMessages.getString("FileImport.invalidSource")); //$NON-NLS-1$
 sourceNameField.setFocus();
     return false;
 }
 /**
  * Execute the passed import operation. Answer a boolean indicating success.
  */
 protected boolean executeImportOperation(ImportOperation op) {
     initializeOperation(op);
      
     try {
         getContainer().run(true, true, op);
     } catch (InterruptedException e) {
         return false;
     } catch (InvocationTargetException e) {
         displayErrorDialog(e.getTargetException().getMessage());
         return false;
     }

     IStatus status = op.getStatus();
     if (!status.isOK()) {
         ErrorDialog.openError(getContainer().getShell(),
             DataTransferMessages.getString("FileImport.importProblems"), //$NON-NLS-1$
 null, // no special message
 status);
         return false;
     }

     return true;
 }
 /**
  * The Finish button was pressed. Try to do the required work now and answer
  * a boolean indicating success. If false is returned then the wizard will
  * not close.
  */
 public boolean finish() {
     if (!ensureSourceIsValid())
         return false;

     if (selectedResources == null && importAllResourcesRadio.getSelection()) {
         // about to invoke the operation so save our state
 saveWidgetValues();

         return importAllResources();
     } else {
         // ensure that files of appropriate extension will be marked as selected
 if (selectedResources == null) {
             if (getFileSystemTree() == null)
                 return false;
         }

         // about to invoke the operation so save our state
 saveWidgetValues();

         if (selectedResources.size() > 0) {
             List fileSystemObjects = new ArrayList(selectedResources.size());
             Iterator resourcesEnum = selectedResources.iterator();
             while (resourcesEnum.hasNext())
                 fileSystemObjects.add(
                     ((FileSystemElement)resourcesEnum.next()).getFileSystemObject());
     
             return importResources(fileSystemObjects);
         }

         MessageDialog.openInformation(
             getContainer().getShell(),
             DataTransferMessages.getString("DataTransfer.information"), //$NON-NLS-1$
 DataTransferMessages.getString("FileImport.noneSelected")); //$NON-NLS-1$

         return false;
     }
 }
 /**
  * Answer the root FileSystemElement that represents the contents of
  * the currently-specified source. If this FileSystemElement is not
  * currently defined then create and return it.
  */
 protected FileSystemElement getFileSystemTree() {
     if (root != null)
         return root;
         
     File sourceDirectory = getSourceDirectory();
     if (sourceDirectory == null)
         return null;

     return selectFiles(sourceDirectory, FileSystemStructureProvider.INSTANCE);
 }
 /**
  * Answer self's import source root element
  */
 protected FileSystemElement getRoot() {
     return root;
 }
 /**
  * Answer self's current collection of selected resources
  */
 protected List getSelectedResources() {
     return selectedResources;
 }
 /**
  * Returns a File object representing the currently-named source directory iff
  * it exists as a valid directory, or <code>null</code> otherwise.
  */
 protected File getSourceDirectory() {
     File sourceDirectory = new File (getSourceDirectoryName());
     if (!sourceDirectory.exists() || !sourceDirectory.isDirectory()) {
         displayErrorDialog(DataTransferMessages.getString("FileImport.invalidSource")); //$NON-NLS-1$
 sourceNameField.setFocus();
         return null;
     }

     return sourceDirectory;
 }
 /**
  * Answer the directory name specified as being the import source.
  * Note that if it ends with a separator then the separator is first
  * removed so that java treats it as a proper directory
  */
 private String getSourceDirectoryName() {
     IPath result = new Path(sourceNameField.getText().trim());

     if (result.getDevice() != null && result.segmentCount() == 0) // something like "c:"
 result = result.addTrailingSeparator();
     else
         result = result.removeTrailingSeparator();

     return result.toOSString();
 }
 /**
  * Answer the string to display as the label for the source specification field
  */
 protected String getSourceLabel() {
     return DataTransferMessages.getString("FileImport.sourceTitle"); //$NON-NLS-1$
 }
 /**
  * Returns a collection of the currently-specified resource types,
  * or <code>null</code> to indicate that all types should be imported.
  */
 protected List getTypesToImport() {
     if (importAllResourcesRadio.getSelection())
         return null;
                     
     List result = new ArrayList();
     StringTokenizer tokenizer = new StringTokenizer(typesToImportField.getText(),TYPE_DELIMITER);
     
     while (tokenizer.hasMoreTokens()) {
         String currentExtension = tokenizer.nextToken().trim();
         if (!currentExtension.equals(""))//$NON-NLS-1$
 result.add(currentExtension);
     }
         
     return result;
 }
 /**
  * Returns an array of the currently-specified resource types,
  * or <code>null</code> to indicate that all types should be imported.
  */
 protected String [] getTypesToImportArray() {
     List typesToImport = getTypesToImport();
     if (typesToImport == null)
         return null;
         
     String result[] = new String [typesToImport.size()];
     typesToImport.toArray(result);

     return result;
 }
 /**
  * Open a selection dialog and note the selections
  */
 protected void handleDetailsButtonPressed() {
     FileSystemElement rootElement = getFileSystemTree();
     
     if (rootElement != null) {
         List newSelections = queryResourcesToImport(rootElement);
         
         if (newSelections != null) {
             selectedResources = newSelections;
             displaySelectedCount(selectedResources.size());
         }
     }
 }
 /**
  * Handle all events and enablements for widgets in this dialog
  */
 public void handleEvent(Event e) {
     Widget source = e.widget;

     if (source == sourceNameField)
         resetSelection();
     else if (source == sourceBrowseButton)
         handleSourceBrowseButtonPressed();
     else if (source == importAllResourcesRadio)
         resetSelection();
     else if (source == importTypedResourcesRadio) {
         resetSelection();
         typesToImportField.setFocus();
     } else if (source == detailsButton)
         handleDetailsButtonPressed();
     else if (source == typesToImportField)
         resetSelection();
     else if (source == typesToImportEditButton)
         handleTypesEditButtonPressed();

     super.handleEvent(e);
 }
 /**
  * Open an appropriate source browser so that the user can specify a source
  * to import from
  */
 protected void handleSourceBrowseButtonPressed() {
     DirectoryDialog dialog = new DirectoryDialog(sourceNameField.getShell(),SWT.SAVE);
     dialog.setMessage(DataTransferMessages.getString("FileImport.selectSource")); //$NON-NLS-1$
 dialog.setFilterPath(getSourceDirectoryName());
     
     String selectedDirectory = dialog.open();
     if (selectedDirectory != null) {
         if (!selectedDirectory.equals(getSourceDirectoryName())) {
             resetSelection();
             sourceNameField.setText(selectedDirectory);
         }
     }
 }
 /**
  * Open a registered type selection dialog and note the selections
  * in self's types-to-export field
  */
 protected void handleTypesEditButtonPressed() {
     IFileEditorMapping editorMappings[] =
         PlatformUI.getWorkbench().getEditorRegistry().getFileEditorMappings();

     List selectedTypes = getTypesToImport();
     List initialSelections = new ArrayList();
     for (int i = 0; i < editorMappings.length; i++) {
         IFileEditorMapping mapping = editorMappings[i];
         if (selectedTypes.contains(mapping.getExtension()))
             initialSelections.add(mapping);
     }

     ListSelectionDialog dialog =
         new ListSelectionDialog(
             getContainer().getShell(),
             editorMappings,
             FileEditorMappingContentProvider.INSTANCE,
             FileEditorMappingLabelProvider.INSTANCE,
             DataTransferMessages.getString("FileImport.selectTypes")); //$NON-NLS-1$

     dialog.setInitialSelections(initialSelections.toArray());
     dialog.setTitle(DataTransferMessages.getString("FileImport.typeSelectionTitle")); //$NON-NLS-1$
 dialog.open();

     Object [] newSelectedTypes = dialog.getResult();
     if (newSelectedTypes != null) { // ie.- did not press Cancel
 List result = new ArrayList(newSelectedTypes.length);
         for (int i = 0; i < newSelectedTypes.length; i++)
             result.add(((IFileEditorMapping)newSelectedTypes[i]).getExtension());
         setTypesToImport(result);
     }
 }
 /**
  * Recursively import all resources starting at the user-specified source location.
  * Answer a boolean indicating success.
  */
 protected boolean importAllResources() {
     return executeImportOperation(
         new ImportOperation(
             getContainerFullPath(),
             getSourceDirectory(),
             FileSystemStructureProvider.INSTANCE,
             this));
 }
 /**
  * Import the resources with extensions as specified by the user
  */
 protected boolean importResources(List fileSystemObjects) {
     return executeImportOperation(
         new ImportOperation(
             getContainerFullPath(),
             getSourceDirectory(),
             FileSystemStructureProvider.INSTANCE,
             this,
             fileSystemObjects));
 }
 /**
  * Initializes the specified operation appropriately.
  */
 protected void initializeOperation(ImportOperation op) {
     op.setCreateContainerStructure(createContainerStructureCheckbox.getSelection());
     op.setOverwriteResources(overwriteExistingResourcesCheckbox.getSelection());
 }
 /**
  * Opens a resource selection dialog with the passed root as input, and returns
  * a collection with the resources that were subsequently specified for import
  * by the user, or <code>null</code> if the dialog was canceled.
  */
 protected List queryResourcesToImport(FileSystemElement rootElement) {
     FileSelectionDialog dialog = new FileSelectionDialog(getContainer().getShell(), rootElement, DataTransferMessages.getString("FileImport.selectResources")); //$NON-NLS-1$
 dialog.setInitialSelections(selectedResources.toArray());
     dialog.setExpandAllOnOpen(true);
     dialog.open();
     if (dialog.getResult() == null)
         return null;
     return Arrays.asList(dialog.getResult());

 }
 /**
  * Reset the selected resources collection and update the ui appropriately
  */
 protected void resetSelection() {
     detailsDescriptionLabel.setText(DataTransferMessages.getString("DataTransfer.allFiles")); //$NON-NLS-1$
 selectedResources = null;
     root = null;
 }
 /**
  * Use the dialog store to restore widget values to the values that they held
  * last time this wizard was used to completion
  */
 protected void restoreWidgetValues() {
     IDialogSettings settings = getDialogSettings();
     if(settings != null) {
         String [] sourceNames = settings.getArray(STORE_SOURCE_NAMES_ID);
         if (sourceNames == null)
             return; // ie.- no values stored, so stop

         // set all/specific types radios and related enablements
 boolean importAll = settings.getBoolean(STORE_IMPORT_ALL_RESOURCES_ID);
         importAllResourcesRadio.setSelection(importAll);
         importTypedResourcesRadio.setSelection(!importAll);

         // set filenames history
 sourceNameField.setText(sourceNames[0]);
         for (int i = 0; i < sourceNames.length; i++)
             sourceNameField.add(sourceNames[i]);

         // set selected types
 String [] selectedTypes = settings.getArray(STORE_SELECTED_TYPES_ID);
         if (selectedTypes.length > 0)
             typesToImportField.setText(selectedTypes[0]);
         for (int i = 0; i < selectedTypes.length; i++)
             typesToImportField.add(selectedTypes[i]);
             
         // radio buttons and checkboxes
 overwriteExistingResourcesCheckbox.setSelection(
             settings.getBoolean(STORE_OVERWRITE_EXISTING_RESOURCES_ID));

         createContainerStructureCheckbox.setSelection(
             settings.getBoolean(STORE_CREATE_CONTAINER_STRUCTURE_ID));
         
     }
 }
 /**
  * Since Finish was pressed, write widget values to the dialog store so that they
  * will persist into the next invocation of this wizard page
  */
 protected void saveWidgetValues() {
     IDialogSettings settings = getDialogSettings();
     if(settings != null) {
         // update source names history
 String [] sourceNames = settings.getArray(STORE_SOURCE_NAMES_ID);
         if (sourceNames == null)
             sourceNames = new String [0];

         sourceNames = addToHistory(sourceNames,getSourceDirectoryName());
         settings.put(
             STORE_SOURCE_NAMES_ID,
             sourceNames);

         // update specific types to import history
 String [] selectedTypesNames = settings.getArray(STORE_SELECTED_TYPES_ID);
         if (selectedTypesNames == null)
             selectedTypesNames = new String [0];

         if (importTypedResourcesRadio.getSelection())
             selectedTypesNames = addToHistory(selectedTypesNames,typesToImportField.getText());
             
         settings.put(
             STORE_SELECTED_TYPES_ID,
             selectedTypesNames);

         // radio buttons and checkboxes
 settings.put(
             STORE_IMPORT_ALL_RESOURCES_ID,
             importAllResourcesRadio.getSelection());
     
         settings.put(
             STORE_OVERWRITE_EXISTING_RESOURCES_ID,
             overwriteExistingResourcesCheckbox.getSelection());

         settings.put(
             STORE_CREATE_CONTAINER_STRUCTURE_ID,
             createContainerStructureCheckbox.getSelection());
     
     }
 }
 /**
  * Invokes a file selection operation using the specified file system and
  * structure provider. If the user specifies files to be imported then
  * this selection is cached for later retrieval and is returned.
  */
 protected FileSystemElement selectFiles(Object rootFileSystemObject,IImportStructureProvider structureProvider) {
     try {
         SelectFilesOperation op =
             new SelectFilesOperation(rootFileSystemObject,structureProvider);
         op.setDesiredExtensions(getTypesToImportArray());
         getContainer().run(true, true, op);
         root = op.getResult();
         setSelectedResources(new ArrayList());
         addToSelectedResources(root);
     } catch (InterruptedException e) {
         return null;
     } catch (InvocationTargetException e) {
         displayErrorDialog(e.getTargetException().getMessage());
         return null;
     }

     return root;
 }
 /**
  * Respond to the user selecting/deselecting items in the
  * extensions list
  */
 public void selectionChanged(SelectionChangedEvent event) {
     if (importTypedResourcesRadio.getSelection())
         resetSelection();
 }
 /**
  * Set self's import source root element
  */
 protected void setRoot(FileSystemElement value) {
     root = value;
 }
 /**
  * Set self's current collection of selected resources
  */
 protected void setSelectedResources(List value) {
     selectedResources = value;
 }
 /**
  * Populate self's import types field based upon the passed types collection
  */
 protected void setTypesToImport(List types) {
     StringBuffer result = new StringBuffer ();
     for (int i = 0; i < types.size(); ++i) {
         if (i != 0) {
             result.append(TYPE_DELIMITER);
             result.append(" ");//$NON-NLS-1$
 }
         result.append(types.get(i));
     }
     typesToImportField.setText(result.toString());
 }
 /**
  * Set the enablements of self's widgets
  */
 protected void updateWidgetEnablements() {
     typesToImportField.setEnabled(importTypedResourcesRadio.getSelection());
     typesToImportEditButton.setEnabled(importTypedResourcesRadio.getSelection());
 }
 /**
  * Answer a boolean indicating whether self's source specification
  * widgets currently all contain valid values.
  */
 protected boolean validateSourceGroup() {
     return !getSourceDirectoryName().equals("");//$NON-NLS-1$
 }
 }

